Displaying Database and API Data in Dynamic Lists

Course: iOS App Development

Topic: Displaying Database and API Data in Dynamic Lists

Course Link: iOS Training at JustAcademy

Demo Link: Register for a Course Demo

Website: JustAcademy Official Website

1. Introduction to Dynamic Lists in iOS

Dynamic lists are a fundamental part of iOS application development. They allow applications to display information that changes over time, such as products, contacts, messages, orders, news articles, expenses, and notifications.

Unlike static lists, dynamic lists retrieve their information from a data source. This data source might be an in-memory array, a local database, a remote API, or a combination of local and remote storage. When records are added, deleted, updated, or downloaded, the interface can refresh to display the latest information.

UIKit provides UITableView for row-based lists and UICollectionView for grids, lists, and flexible layouts. SwiftUI also provides views such as List for displaying collections of data. The appropriate choice depends on the framework and architecture used by the application.

Learning Objectives

• Understand how dynamic lists work in iOS applications.
• Learn the difference between database data and API data.
• Create Swift model objects for records returned by an API.
• Display data using UITableView and UICollectionView.
• Retrieve remote information using URLSession.
• Read and manage locally stored data using SQLite or Core Data.
• Implement loading, success, empty, and error states.
• Support search, filtering, sorting, refreshing, and pagination.
• Combine API responses with local database storage.
• Improve application performance, reliability, and security.

2. Understanding Dynamic Data Sources

A dynamic list needs a reliable source of information. The source determines where the data comes from, how long it remains available, and how the application updates it.

Typical Data Flow

1. The application requests data from a database or remote server.
2. The returned records are converted into Swift model objects.
3. The application stores the records in memory or persistent storage.
4. The list data source supplies the required records to visible cells.
5. The user interacts with the list through searching, selecting, or refreshing.
6. The application updates the model and refreshes the interface when data changes.

3. Creating Swift Model Objects

A model represents a record in the application. Keeping data in model objects separates business information from the user interface and makes it easier to decode API responses or map database records.

For example, a product model can contain an ID, title, price, and category.

import Foundation

struct Product: Codable, Identifiable, Hashable {
    let id: Int
    let title: String
    let price: Double
    let category: String
}

Codable supports encoding and decoding, including JSON decoding. Identifiable provides a consistent way to identify each product, and Hashable is useful for diffable data sources and other identifier-based operations.

Model fields should match the data returned by the API or stored in the database. If the server uses different field names, use CodingKeys to map them to the desired Swift properties.

Mapping API Field Names

struct Article: Codable, Identifiable {
    let id: Int
    let title: String
    let description: String

    enum CodingKeys: String, CodingKey {
        case id
        case title
        case description = "body"
    }
}

In this example, the API provides the text under the JSON key body, while the Swift model uses the property name description. Coding keys make this mapping explicit.

4. Displaying Data Using UITableView

UITableView is commonly used to display records in a vertically scrolling list. Each row represents an item, and rows can be organized into sections.

Step 1: Create a Table View Controller

The following example demonstrates how to display products from a Swift array. The table view must be initialized and configured before it is used.

import UIKit

@MainActor
final class ProductListViewController: UIViewController,
                                       UITableViewDataSource {
    private let tableView = UITableView()
    private var products: [Product] = []

    override func viewDidLoad() {
        super.viewDidLoad()

        tableView.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(tableView)

        NSLayoutConstraint.activate([
            tableView.topAnchor.constraint(
                equalTo: view.safeAreaLayoutGuide.topAnchor
            ),
            tableView.leadingAnchor.constraint(
                equalTo: view.leadingAnchor
            ),
            tableView.trailingAnchor.constraint(
                equalTo: view.trailingAnchor
            ),
            tableView.bottomAnchor.constraint(
                equalTo: view.bottomAnchor
            )
        ])

        tableView.register(
            UITableViewCell.self,
            forCellReuseIdentifier: "ProductCell"
        )

        tableView.dataSource = self
    }

    func tableView(
        _ tableView: UITableView,
        numberOfRowsInSection section: Int
    ) -> Int {
        products.count
    }

    func tableView(
        _ tableView: UITableView,
        cellForRowAt indexPath: IndexPath
    ) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(
            withIdentifier: "ProductCell",
            for: indexPath
        )

        let product = products[indexPath.row]

        var content = cell.defaultContentConfiguration()
        content.text = product.title
        content.secondaryText = String(
            format: "$%.2f", product.price
        )
        cell.contentConfiguration = content

        return cell
    }
}

The data source provides the number of rows and configures each visible cell. The products array is the current source of the displayed information.

To complete this example, populate products from an API or database and refresh the table view after the data changes. The example uses Auto Layout constraints so that the table view adapts to the available screen size.

Why Reusable Cells Are Important

Table views reuse cells as the user scrolls. Rather than creating a separate cell for every record, UIKit reuses cells that move offscreen. This reduces memory usage and supports smoother scrolling.

Keep cell configuration methods fast. Avoid performing network requests, large database queries, or expensive calculations directly inside cellForRowAt. Retrieve the data first and then configure the visible cell.

5. Displaying Data Using UICollectionView

UICollectionView is useful when information needs to be arranged in grids, image galleries, product cards, or custom layouts. It supports reusable cells and flexible layout options.

Basic Setup Process

1. Create a collection view and configure its layout.
2. Register a compatible cell class or cell registration.
3. Prepare the models that will appear in the list.
4. Configure a data source to supply cells for each item.
5. Refresh the collection view when the displayed data changes.

For a collection that changes frequently, consider UICollectionViewDiffableDataSource. It uses stable identifiers and snapshots to describe the desired list state, allowing UIKit to calculate insertions, deletions, and moves.

enum Section {
    case main
}

var snapshot =
    NSDiffableDataSourceSnapshot<Section, Product.ID>()

snapshot.appendSections([.main])
snapshot.appendItems(products.map(\.id), toSection: .main)

dataSource.apply(snapshot, animatingDifferences: true)

This snippet assumes that the collection view's diffable data source and its cell provider have already been configured. The model store must be able to find each product using its ID, and identifiers must be unique and stable.

6. Fetching API Data Using URLSession

Many iOS applications retrieve information from remote servers. A REST API commonly returns data in JSON format, which the application decodes into Swift model objects before displaying it.

URLSession is Apple's networking API for making HTTP requests and receiving responses. Modern Swift applications can use async/await to write asynchronous network code without blocking the main thread.

Step 1: Understand the JSON Response

An API might return an array of products in the following format:

[
    {
        "id": 1,
        "title": "Wireless Headphones",
        "price": 79.99,
        "category": "Electronics"
    },
    {
        "id": 2,
        "title": "Travel Backpack",
        "price": 39.50,
        "category": "Accessories"
    }
]

The response structure determines how the Swift model should be defined. Check the API documentation to confirm field names, types, optional values, and whether the records are returned directly as an array or inside a wrapper object.

Step 2: Build an API Service

import Foundation

enum ProductAPIError: Error {
    case invalidResponse
    case unsuccessfulStatusCode(Int)
}

struct ProductAPIService {
    func fetchProducts() async throws -> [Product] {
        guard let url = URL(
            string: "https://api.example.com/products"
        ) else {
            throw URLError(.badURL)
        }

        let (data, response) = try await URLSession.shared.data(
            from: url
        )

        guard let httpResponse = response as? HTTPURLResponse
        else {
            throw ProductAPIError.invalidResponse
        }

        guard (200...299).contains(httpResponse.statusCode)
        else {
            throw ProductAPIError.unsuccessfulStatusCode(
                httpResponse.statusCode
            )
        }

        return try JSONDecoder().decode(
            [Product].self,
            from: data
        )
    }
}

Important: https://api.example.com/products is a placeholder URL, not a working product API. Replace it with your actual API endpoint. This implementation checks the HTTP status code and decodes the response into an array of products.

Step 3: Load API Data into the View Controller

private let apiService = ProductAPIService()

private func loadProducts() {
    Task {
        do {
            let fetchedProducts = try await apiService.fetchProducts()
            products = fetchedProducts
            tableView.reloadData()
        } catch {
            print("Failed to load products:", error)
        }
    }
}

Call loadProducts() after configuring the table view. Because the view controller is isolated to the main actor in the earlier example, its UI-related state updates remain on the main actor.

In a production application, show a loading indicator while the request is running, display a helpful error message on failure, and provide a retry option where appropriate. Also consider cancelling requests that are no longer needed.

7. Understanding API Request and Response Handling

A successful network connection does not automatically mean that an API request succeeded. The server can return an HTTP error, an unexpected content type, malformed JSON, or a response that does not match the model.

Important Response Checks

• Transport errors: Handle connection failures, timeouts, and other networking errors.
• HTTP status codes: Check whether the server returned a successful status, commonly within the 200–299 range.
• Response format: Confirm that the data is in the expected format, such as JSON.
• Decoding: Handle missing keys, incorrect types, and unexpected response structures.
• Authentication: Handle expired credentials and unauthorized responses appropriately.
• Request cancellation: Cancel work that is no longer needed, such as outdated search requests.

Do not display technical server details directly to users. Log appropriate diagnostic information during development and present clear, user-friendly messages in the interface.

8. Retrieving Records from a Local Database

A local database stores information on the device so that it can persist between application launches. Local storage is useful for offline access, saved content, user-created records, and caching server responses.

SQLite

SQLite is a relational database engine that stores structured information in tables. It supports SQL statements for inserting, reading, updating, and deleting records.

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    title TEXT NOT NULL,
    price REAL NOT NULL,
    category TEXT NOT NULL
);

This statement creates a products table with an integer primary key and fields for the title, price, and category.

Reading Database Records

SELECT id, title, price, category
FROM products
ORDER BY title ASC;

This query retrieves the product fields and sorts the records alphabetically by title. A database repository can execute the query, map each result into a Swift model, and return the models to the list screen.

SQLite operations require a suitable database library or SQLite integration in the application. The SQL snippets above demonstrate the query logic; they are not a complete database connection implementation.

Core Data

Core Data is an Apple framework for managing object graphs and persistence. It supports model entities, relationships, change tracking, and storage integrations. It is often used when an application needs a structured persistence layer with object-oriented access.

For table views driven by Core Data, an NSFetchedResultsController can observe changes in fetched records and help keep the interface synchronized. In other architectures, a repository can fetch managed objects or map them into presentation models.

Database Best Practices

• Keep database access separate from view controller code.
• Use parameterized SQL queries instead of concatenating user input.
• Perform expensive database operations off the main thread.
• Use transactions when related updates must succeed or fail together.
• Add indexes for frequently searched or sorted fields when appropriate.
• Handle schema migrations when the database structure changes.
• Handle database errors instead of silently ignoring failed operations.

9. Combining API Data with a Local Database

Many applications use a remote API for current information and a local database for persistence. This approach can improve startup performance and allow previously downloaded information to remain available offline.

For example, a news application can display locally saved articles immediately and then retrieve newer articles from the server. A product application can show cached product details while refreshing prices and availability.

Recommended Data Flow

1. Open the screen and retrieve previously saved records from the local database.
2. Display cached records when available.
3. Start an asynchronous API request for fresh information.
4. Validate the HTTP response and decode the returned data.
5. Save new or updated records to the local database.
6. Refresh the displayed list using the updated model data.
7. If the network request fails, preserve cached data when appropriate and inform the user that the latest information could not be retrieved.

Benefits of Local Caching

• Faster initial display of previously loaded information.
• Better user experience on slow connections.
• Access to cached records when offline.
• Reduced need to download unchanged content repeatedly.
• Persistent storage for user-created information.

Define which source is authoritative for each field. If a user can edit records locally while the server also updates them, establish conflict-resolution rules using version numbers, timestamps, or server-defined update policies.

10. Implementing Loading and Empty States

A dynamic list should communicate what is happening. Users should be able to distinguish between a request that is still loading, a successful response containing no records, and a request that failed.

Example Loading Indicator

private let activityIndicator = UIActivityIndicatorView(
    style: .large
)

private func configureActivityIndicator() {
    activityIndicator.translatesAutoresizingMaskIntoConstraints = false
    view.addSubview(activityIndicator)

    NSLayoutConstraint.activate([
        activityIndicator.centerXAnchor.constraint(
            equalTo: view.centerXAnchor
        ),
        activityIndicator.centerYAnchor.constraint(
            equalTo: view.centerYAnchor
        )
    ])
}

private func showLoading() {
    activityIndicator.startAnimating()
}

private func hideLoading() {
    activityIndicator.stopAnimating()
}

Configure the activity indicator once and reuse it. Start it before the asynchronous operation and stop it when the operation completes, regardless of success or failure.

Example Empty State

private let emptyStateLabel = UILabel()

private func configureEmptyState() {
    emptyStateLabel.text = "No products available"
    emptyStateLabel.textAlignment = .center
    emptyStateLabel.numberOfLines = 0
    tableView.backgroundView = emptyStateLabel
}

private func updateEmptyState() {
    tableView.backgroundView = products.isEmpty
        ? emptyStateLabel
        : nil
}

Call configureEmptyState() during screen setup and updateEmptyState() after the data changes. In a more advanced application, distinguish between an empty list caused by a search filter and an empty response from the server.

11. Pull-to-Refresh Functionality

Pull-to-refresh lets users manually request fresh information by pulling down on a scrollable list. UIKit provides UIRefreshControl for this interaction.

private let refreshControl = UIRefreshControl()

private func configureRefreshControl() {
    refreshControl.addTarget(
        self,
        action: #selector(refreshProducts),
        for: .valueChanged
    )

    tableView.refreshControl = refreshControl
}

@objc private func refreshProducts() {
    Task {
        defer {
            refreshControl.endRefreshing()
        }

        do {
            products = try await apiService.fetchProducts()
            tableView.reloadData()
            updateEmptyState()
        } catch {
            print("Refresh failed:", error)
        }
    }
}

This example assumes that the view controller is main-actor isolated and that apiService and updateEmptyState() are defined. Call configureRefreshControl() during setup.

The defer statement ensures that the refresh animation stops when the operation exits. In a production app, preserve previously loaded records if refresh fails, show a clear error message, and avoid starting overlapping refresh requests without appropriate coordination.

12. Search, Filtering, and Sorting

Search and filtering help users locate records without manually scrolling through an entire list. These operations can be performed in memory for small datasets or delegated to the database or API for larger collections.

Filtering Products by Name

func filterProducts(
    _ products: [Product],
    searchText: String
) -> [Product] {
    let query = searchText.trimmingCharacters(
        in: .whitespacesAndNewlines
    )

    guard !query.isEmpty else {
        return products
    }

    return products.filter {
        $0.title.localizedCaseInsensitiveContains(query)
    }
}

This function returns products whose titles contain the search term, without changing the original array. When the search field becomes empty, the complete list can be displayed again.

Sorting by Price

let sortedProducts = products.sorted {
    $0.price < $1.price
}

This sorts the products from lowest price to highest price. Reverse the comparison to sort from highest to lowest.

Search and Filtering Best Practices

• Keep original records separate from filtered results.
• Trim leading and trailing whitespace from search input.
• Use case-insensitive matching for common user-facing searches.
• Debounce frequent search input when filtering is expensive.
• Cancel or ignore outdated asynchronous search requests.
• Display a useful message when no records match.
• Use database queries or server-side filters for large datasets when appropriate.

13. Pagination and Large Datasets

Loading thousands of records in a single API request can increase memory usage and delay the initial display. Pagination divides a large result set into smaller batches, allowing the application to load information progressively.

An API may support page numbers, offsets, page sizes, or cursor-based pagination. Follow the specific format documented by the server.

Example Pagination Model

struct ProductPage: Decodable {
    let items: [Product]
    let nextPage: Int?
}

This is an illustrative model. If the actual API uses keys such as results, page, or next, adjust the model or use CodingKeys to match the response.

Pagination Workflow

1. Fetch the first batch when the screen opens.
2. Display the returned records.
3. Track the next page number or cursor.
4. Request the next batch when the user approaches the end of the list.
5. Append new records while avoiding duplicate identifiers.
6. Stop fetching when the API indicates that no more pages are available.
7. Provide a retry mechanism if a later page fails to load.

Prevent repeated requests for the same page while a request is already running. For APIs that change frequently, consider whether new or deleted server records can affect page boundaries and result consistency.

14. Updating Lists with Diffable Data Sources

Diffable data sources simplify the process of keeping a collection view or table view synchronized with changing model data. Instead of manually calculating every row insertion or deletion, the developer creates a snapshot describing the desired state.

Example Snapshot

enum ProductSection {
    case main
}

func applyProducts(
    _ products: [Product],
    to dataSource: UICollectionViewDiffableDataSource<
        ProductSection, Product.ID
    >
) {
    var snapshot =
        NSDiffableDataSourceSnapshot<
            ProductSection, Product.ID
        >()

    snapshot.appendSections([.main])
    snapshot.appendItems(
        products.map(\.id),
        toSection: .main
    )

    dataSource.apply(snapshot, animatingDifferences: true)
}

This function assumes that the collection view and diffable data source have already been configured. The cell provider must be able to look up each product using its ID. Update the model store before applying the snapshot so that cells can display the latest values.

Advantages

• Reduces manual coordination of insertions and deletions.
• Supports animated list updates.
• Tracks items through stable identifiers.
• Works well with lists containing multiple sections.
• Makes complex UI state changes easier to reason about.

Diffable data sources are especially useful when lists change frequently. For simple lists with limited update requirements, a conventional data source may be sufficient.

15. Performance Optimization

List performance depends on network latency, database queries, model decoding, cell configuration, image loading, and the frequency of UI updates. Efficient data retrieval alone is not enough if each cell performs expensive work.

Recommended Optimization Techniques

• Reuse cells: Dequeue reusable cells instead of creating new cells for every record.
• Keep cell configuration fast: Avoid lengthy operations in cell configuration methods.
• Use asynchronous requests: Keep the main thread available for rendering and user interactions.
• Cache images: Avoid repeatedly downloading the same image as cells move on and offscreen.
• Use pagination: Load records in manageable batches.
• Optimize database queries: Use suitable indexes and avoid fetching unnecessary fields.
• Minimize unnecessary refreshes: Refresh only changed items when practical.
• Prefetch when useful: Start expensive data work before a cell becomes visible.
• Profile the app: Use Xcode Instruments to investigate memory use, CPU usage, and scrolling performance.
• Handle cancellation: Stop obsolete network requests and image-loading tasks when possible.

16. Common Errors and Troubleshooting

17. Security and Data Integrity

Applications that display API and database information must protect sensitive data and validate information received from external sources.

• Use HTTPS for network communication.
• Never embed private server credentials or secret API keys directly in the app.
• Use appropriate authentication and authorization for protected endpoints.
• Validate response data before using it in business logic.
• Use parameterized SQL statements to avoid SQL injection.
• Avoid logging passwords, access tokens, or sensitive personal information.
• Store sensitive credentials using secure storage such as Keychain when appropriate.
• Handle expired sessions and unauthorized responses safely.
• Use transactions and conflict-handling rules for important database changes.
• Define how local edits are synchronized with server updates.

18. Practical Project: Product Directory Application

Project Goal: Build an iOS application that retrieves product data from an API, displays the records in a dynamic list, and stores a local copy for offline access.

Required Features

• Display products using a table view or collection view.
• Fetch product data from a remote API.
• Decode JSON into Swift model objects.
• Show a loading indicator during requests.
• Display separate empty and error states.
• Support pull-to-refresh.
• Implement search and sorting.
• Store downloaded products locally.
• Show previously saved records when the network is unavailable.
• Implement pagination if the API provides large result sets.
• Refresh the list when products are added, removed, or updated.

Suggested Application Architecture

Development Steps

1. Create a new iOS project in Xcode.
2. Define a product model with a stable identifier.
3. Build the table view or collection view interface.
4. Create an API service using URLSession.
5. Decode the API response using JSONDecoder.
6. Populate the list using the returned model objects.
7. Add loading feedback and error handling.
8. Implement refresh, search, and sorting.
9. Integrate SQLite or Core Data for local persistence.
10. Test offline access, pagination, duplicate records, and slow networks.

Expected Result

The application should display product information efficiently, remain responsive while loading data, and provide useful feedback when information is unavailable. When local persistence is enabled, previously saved records should remain available offline according to the application's caching strategy.

19. Practice Exercises

1. Create a table view that displays records from a Swift array.
2. Fetch a JSON array from an API and decode it into Swift model objects.
3. Add a retry button for failed network requests.
4. Implement a search field that filters records by name.
5. Add pull-to-refresh and prevent overlapping refresh requests.
6. Save downloaded records to a local database.
7. Display locally saved records after restarting the application.
8. Implement pagination using the API's documented format.
9. Use a diffable data source to animate insertions and deletions.
10. Test the application when the API returns an empty array.
11. Test how the list behaves when the network disconnects during refresh.
12. Measure scrolling performance with a large set of records.

20. Interview Questions and Answers

Q1. What is a dynamic list in iOS?

Answer: A dynamic list displays records that can change over time. Its data may come from an array, local database, remote API, or a combination of sources.

Q2. What is the difference between UITableView and UICollectionView?

Answer: UITableView is commonly used for vertically arranged rows. UICollectionView supports flexible layouts, including grids, lists, and custom arrangements.

Q3. What is URLSession?

Answer: URLSession is Apple's networking API for sending requests and receiving data from remote servers.

Q4. What is Codable?

Answer: Codable combines encoding and decoding capabilities in Swift. It allows compatible model types to be converted to and from JSON and other supported formats.

Q5. Why should network requests not run inside cellForRowAt?

Answer: Cell configuration should be fast. Network requests have unpredictable latency and can make scrolling slow if performed synchronously during cell configuration.

Q6. What is the purpose of a local database?

Answer: A local database stores structured information on the device so records can persist between launches and remain available offline when the application supports it.

Q7. What is the difference between SQLite and Core Data?

Answer: SQLite is a relational database engine queried using SQL. Core Data is an object graph and persistence framework that manages model objects, relationships, and change tracking.

Q8. Why is cell reuse important?

Answer: Cell reuse reduces repeated allocations and helps control memory usage when lists contain many records.

Q9. What is pagination?

Answer: Pagination retrieves records in smaller batches instead of downloading a complete large dataset in one request.

Q10. What is a diffable data source?

Answer: It is a UIKit data source that uses stable identifiers and snapshots to manage list state and calculate interface changes.

Q11. How should an application handle API failures?

Answer: It should handle the error, display a helpful message, provide a retry option when appropriate, and preserve previously loaded data when that is safe and useful.

Q12. How can an application support offline access?

Answer: Store records locally and load them when the screen opens. Refresh from the server when possible and synchronize changes according to the application's data rules.

21. Quick Revision Checklist

• Understand the different sources of dynamic data.
• Create Swift models that match API responses or database records.
• Configure table view and collection view data sources.
• Use URLSession for asynchronous network operations.
• Validate HTTP responses and handle JSON decoding errors.
• Separate API, database, model, and UI responsibilities.
• Display loading, success, empty, and error states.
• Use local persistence when offline access is required.
• Implement search, sorting, refresh, and pagination carefully.
• Use stable identifiers and diffable data sources when appropriate.
• Optimize reusable cells, image loading, and database queries.
• Protect sensitive data and handle network failures gracefully.

22. Conclusion

Displaying database and API data in dynamic lists is an important skill in iOS development. It requires developers to retrieve information, decode responses, manage persistent storage, configure reusable cells, and keep the interface synchronized with changing records.

By combining UITableView or UICollectionView with URLSession, suitable database storage, and reliable state management, developers can build applications that display changing information efficiently. Asynchronous processing, clear error handling, pagination, and local caching help make these applications responsive and reliable.

23. Additional Learning Resources

• Apple Developer Documentation: Filling a Table with Data
• Apple Developer Documentation: UICollectionView
• Apple Developer Documentation: URLSession
• Apple Developer Documentation: Codable
• Apple Developer Documentation: Core Data
• Apple Developer Documentation: UITableViewDiffableDataSource
• Explore iOS Training at JustAcademy
• Register for a JustAcademy Course Demo
• Visit the JustAcademy Official Website